// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.fbainvoice.detail;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.FBAInvoiceDetail;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(FBAInvoiceDetail.class)
@Setter
@Getter
public class FBAInvoiceDetailSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "FBAInvoiceDetail".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("name", "p");
    map.put("shopId", "si");
    map.put("parentFBAInvoice", "fbai");
    map.put("warehouse", "w");
    map.put("shipmentShop", "si2");
    map.put("warehouseBin", "wb");
    map.put("outBingId", "wb2");
    map.put("inBingId", "wb3");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 货件号(模糊搜索)
   */
  private String shipmentCode;

  /**
   * 货件号 比较(eq)
   */
  private String shipmentCodeEq;
  /**
   * 货件号 比较(neq)
   */
  private String shipmentCodeNeq;
  /**
   * 货件号 比较(gt)
   */
  private String shipmentCodeGt;
  /**
   * 货件号 比较(gte)
   */
  private String shipmentCodeGte;
  /**
   * 货件号 比较(lt)
   */
  private String shipmentCodeLt;
  /**
   * 货件号 比较(lte)
   */
  private String shipmentCodeLte;
  /**
   * 货件号 比较(contains)
   */
  private String shipmentCodeContains;
  /**
   * 货件号 比较(notcontains)
   */
  private String shipmentCodeNotcontains;
  /**
   * 货件号 比较(startswith)
   */
  private String shipmentCodeStartswith;
  /**
   * 货件号 比较(endswith)
   */
  private String shipmentCodeEndswith;
  /**
   * 货件号 比较(isnull)
   */
  private Boolean shipmentCodeIsnull;
  /**
   * 货件号 比较(isnotnull)
   */
  private Boolean shipmentCodeIsnotnull;

  /**
   * 货件号(精确搜索)
   */
  private List<String> shipmentCodeInList;

  /**
   * 货件状态(模糊搜索)
   */
  private String shipmentStatus;

  /**
   * 货件状态 比较(eq)
   */
  private String shipmentStatusEq;
  /**
   * 货件状态 比较(neq)
   */
  private String shipmentStatusNeq;
  /**
   * 货件状态 比较(gt)
   */
  private String shipmentStatusGt;
  /**
   * 货件状态 比较(gte)
   */
  private String shipmentStatusGte;
  /**
   * 货件状态 比较(lt)
   */
  private String shipmentStatusLt;
  /**
   * 货件状态 比较(lte)
   */
  private String shipmentStatusLte;
  /**
   * 货件状态 比较(contains)
   */
  private String shipmentStatusContains;
  /**
   * 货件状态 比较(notcontains)
   */
  private String shipmentStatusNotcontains;
  /**
   * 货件状态 比较(startswith)
   */
  private String shipmentStatusStartswith;
  /**
   * 货件状态 比较(endswith)
   */
  private String shipmentStatusEndswith;
  /**
   * 货件状态 比较(isnull)
   */
  private Boolean shipmentStatusIsnull;
  /**
   * 货件状态 比较(isnotnull)
   */
  private Boolean shipmentStatusIsnotnull;

  /**
   * 货件状态(精确搜索)
   */
  private List<String> shipmentStatusInList;

  /**
   * 是否有 图片
   */
  private Boolean picUrl;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnskuInList;

  /**
   * ASIN(模糊搜索)
   */
  private String asin;

  /**
   * ASIN 比较(eq)
   */
  private String asinEq;
  /**
   * ASIN 比较(neq)
   */
  private String asinNeq;
  /**
   * ASIN 比较(gt)
   */
  private String asinGt;
  /**
   * ASIN 比较(gte)
   */
  private String asinGte;
  /**
   * ASIN 比较(lt)
   */
  private String asinLt;
  /**
   * ASIN 比较(lte)
   */
  private String asinLte;
  /**
   * ASIN 比较(contains)
   */
  private String asinContains;
  /**
   * ASIN 比较(notcontains)
   */
  private String asinNotcontains;
  /**
   * ASIN 比较(startswith)
   */
  private String asinStartswith;
  /**
   * ASIN 比较(endswith)
   */
  private String asinEndswith;
  /**
   * ASIN 比较(isnull)
   */
  private Boolean asinIsnull;
  /**
   * ASIN 比较(isnotnull)
   */
  private Boolean asinIsnotnull;

  /**
   * ASIN(精确搜索)
   */
  private List<String> asinInList;

  /**
   * 父ASIN(模糊搜索)
   */
  private String parentAsin;

  /**
   * 父ASIN 比较(eq)
   */
  private String parentAsinEq;
  /**
   * 父ASIN 比较(neq)
   */
  private String parentAsinNeq;
  /**
   * 父ASIN 比较(gt)
   */
  private String parentAsinGt;
  /**
   * 父ASIN 比较(gte)
   */
  private String parentAsinGte;
  /**
   * 父ASIN 比较(lt)
   */
  private String parentAsinLt;
  /**
   * 父ASIN 比较(lte)
   */
  private String parentAsinLte;
  /**
   * 父ASIN 比较(contains)
   */
  private String parentAsinContains;
  /**
   * 父ASIN 比较(notcontains)
   */
  private String parentAsinNotcontains;
  /**
   * 父ASIN 比较(startswith)
   */
  private String parentAsinStartswith;
  /**
   * 父ASIN 比较(endswith)
   */
  private String parentAsinEndswith;
  /**
   * 父ASIN 比较(isnull)
   */
  private Boolean parentAsinIsnull;
  /**
   * 父ASIN 比较(isnotnull)
   */
  private Boolean parentAsinIsnotnull;

  /**
   * 父ASIN(精确搜索)
   */
  private List<String> parentAsinInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 品名
   */
  private Long name;

  /**
   * 品名 比较(eq)
   */
  private Long nameEq;
  /**
   * 品名 比较(neq)
   */
  private Long nameNeq;
  /**
   * 品名 比较(gt)
   */
  private Long nameGt;
  /**
   * 品名 比较(gte)
   */
  private Long nameGte;
  /**
   * 品名 比较(lt)
   */
  private Long nameLt;
  /**
   * 品名 比较(lte)
   */
  private Long nameLte;
  /**
   * 品名 比较(contains)
   */
  private Long nameContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long nameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long nameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long nameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean nameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean nameIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String nameNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String nameNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String nameNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String nameNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String nameNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String nameNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String nameNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String nameNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String nameNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String nameNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean nameNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean nameNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> nameInList;

  /**
   * 店铺
   */
  private Long shopId;

  /**
   * 店铺 比较(eq)
   */
  private Long shopIdEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopIdNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopIdGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopIdGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopIdLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopIdLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopIdContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopIdNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopIdStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopIdEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopIdIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopIdIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopIdShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopIdShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopIdShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopIdShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopIdShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopIdShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopIdShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopIdShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopIdShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopIdShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopIdShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopIdShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopIdInList;

  /**
   * 国家(模糊搜索)
   */
  private String country;

  /**
   * 国家 比较(eq)
   */
  private String countryEq;
  /**
   * 国家 比较(neq)
   */
  private String countryNeq;
  /**
   * 国家 比较(gt)
   */
  private String countryGt;
  /**
   * 国家 比较(gte)
   */
  private String countryGte;
  /**
   * 国家 比较(lt)
   */
  private String countryLt;
  /**
   * 国家 比较(lte)
   */
  private String countryLte;
  /**
   * 国家 比较(contains)
   */
  private String countryContains;
  /**
   * 国家 比较(notcontains)
   */
  private String countryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String countryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String countryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> countryInList;

  /**
   * 计划发货量
   */
  private Integer planSendQuantity;

  /**
   * 最小计划发货量
   */
  private Integer planSendQuantityMin;

  /**
   * 最大计划发货量
   */
  private Integer planSendQuantityMax;

  /**
   * 计划发货量 比较(eq)
   */
  private Integer planSendQuantityEq;
  /**
   * 计划发货量 比较(neq)
   */
  private Integer planSendQuantityNeq;
  /**
   * 计划发货量 比较(gt)
   */
  private Integer planSendQuantityGt;
  /**
   * 计划发货量 比较(gte)
   */
  private Integer planSendQuantityGte;
  /**
   * 计划发货量 比较(lt)
   */
  private Integer planSendQuantityLt;
  /**
   * 计划发货量 比较(lte)
   */
  private Integer planSendQuantityLte;
  /**
   * 计划发货量 比较(contains)
   */
  private Integer planSendQuantityContains;
  /**
   * 计划发货量 比较(notcontains)
   */
  private Integer planSendQuantityNotcontains;
  /**
   * 计划发货量 比较(startswith)
   */
  private Integer planSendQuantityStartswith;
  /**
   * 计划发货量 比较(endswith)
   */
  private Integer planSendQuantityEndswith;
  /**
   * 计划发货量 比较(isnull)
   */
  private Boolean planSendQuantityIsnull;
  /**
   * 计划发货量 比较(isnotnull)
   */
  private Boolean planSendQuantityIsnotnull;

  /**
   * 申报量
   */
  private Integer declarationQuantity;

  /**
   * 最小申报量
   */
  private Integer declarationQuantityMin;

  /**
   * 最大申报量
   */
  private Integer declarationQuantityMax;

  /**
   * 申报量 比较(eq)
   */
  private Integer declarationQuantityEq;
  /**
   * 申报量 比较(neq)
   */
  private Integer declarationQuantityNeq;
  /**
   * 申报量 比较(gt)
   */
  private Integer declarationQuantityGt;
  /**
   * 申报量 比较(gte)
   */
  private Integer declarationQuantityGte;
  /**
   * 申报量 比较(lt)
   */
  private Integer declarationQuantityLt;
  /**
   * 申报量 比较(lte)
   */
  private Integer declarationQuantityLte;
  /**
   * 申报量 比较(contains)
   */
  private Integer declarationQuantityContains;
  /**
   * 申报量 比较(notcontains)
   */
  private Integer declarationQuantityNotcontains;
  /**
   * 申报量 比较(startswith)
   */
  private Integer declarationQuantityStartswith;
  /**
   * 申报量 比较(endswith)
   */
  private Integer declarationQuantityEndswith;
  /**
   * 申报量 比较(isnull)
   */
  private Boolean declarationQuantityIsnull;
  /**
   * 申报量 比较(isnotnull)
   */
  private Boolean declarationQuantityIsnotnull;

  /**
   * 发货量
   */
  private Integer sendQuantity;

  /**
   * 最小发货量
   */
  private Integer sendQuantityMin;

  /**
   * 最大发货量
   */
  private Integer sendQuantityMax;

  /**
   * 发货量 比较(eq)
   */
  private Integer sendQuantityEq;
  /**
   * 发货量 比较(neq)
   */
  private Integer sendQuantityNeq;
  /**
   * 发货量 比较(gt)
   */
  private Integer sendQuantityGt;
  /**
   * 发货量 比较(gte)
   */
  private Integer sendQuantityGte;
  /**
   * 发货量 比较(lt)
   */
  private Integer sendQuantityLt;
  /**
   * 发货量 比较(lte)
   */
  private Integer sendQuantityLte;
  /**
   * 发货量 比较(contains)
   */
  private Integer sendQuantityContains;
  /**
   * 发货量 比较(notcontains)
   */
  private Integer sendQuantityNotcontains;
  /**
   * 发货量 比较(startswith)
   */
  private Integer sendQuantityStartswith;
  /**
   * 发货量 比较(endswith)
   */
  private Integer sendQuantityEndswith;
  /**
   * 发货量 比较(isnull)
   */
  private Boolean sendQuantityIsnull;
  /**
   * 发货量 比较(isnotnull)
   */
  private Boolean sendQuantityIsnotnull;

  /**
   * 发货计划(模糊搜索)
   */
  private String planShipCode;

  /**
   * 发货计划 比较(eq)
   */
  private String planShipCodeEq;
  /**
   * 发货计划 比较(neq)
   */
  private String planShipCodeNeq;
  /**
   * 发货计划 比较(gt)
   */
  private String planShipCodeGt;
  /**
   * 发货计划 比较(gte)
   */
  private String planShipCodeGte;
  /**
   * 发货计划 比较(lt)
   */
  private String planShipCodeLt;
  /**
   * 发货计划 比较(lte)
   */
  private String planShipCodeLte;
  /**
   * 发货计划 比较(contains)
   */
  private String planShipCodeContains;
  /**
   * 发货计划 比较(notcontains)
   */
  private String planShipCodeNotcontains;
  /**
   * 发货计划 比较(startswith)
   */
  private String planShipCodeStartswith;
  /**
   * 发货计划 比较(endswith)
   */
  private String planShipCodeEndswith;
  /**
   * 发货计划 比较(isnull)
   */
  private Boolean planShipCodeIsnull;
  /**
   * 发货计划 比较(isnotnull)
   */
  private Boolean planShipCodeIsnotnull;

  /**
   * 发货计划(精确搜索)
   */
  private List<String> planShipCodeInList;

  /**
   * 总净重
   */
  private java.math.BigDecimal totalSuttle;

  /**
   * 最小总净重
   */
  private java.math.BigDecimal totalSuttleMin;

  /**
   * 最大总净重
   */
  private java.math.BigDecimal totalSuttleMax;

  /**
   * 总净重 比较(eq)
   */
  private java.math.BigDecimal totalSuttleEq;
  /**
   * 总净重 比较(neq)
   */
  private java.math.BigDecimal totalSuttleNeq;
  /**
   * 总净重 比较(gt)
   */
  private java.math.BigDecimal totalSuttleGt;
  /**
   * 总净重 比较(gte)
   */
  private java.math.BigDecimal totalSuttleGte;
  /**
   * 总净重 比较(lt)
   */
  private java.math.BigDecimal totalSuttleLt;
  /**
   * 总净重 比较(lte)
   */
  private java.math.BigDecimal totalSuttleLte;
  /**
   * 总净重 比较(contains)
   */
  private java.math.BigDecimal totalSuttleContains;
  /**
   * 总净重 比较(notcontains)
   */
  private java.math.BigDecimal totalSuttleNotcontains;
  /**
   * 总净重 比较(startswith)
   */
  private java.math.BigDecimal totalSuttleStartswith;
  /**
   * 总净重 比较(endswith)
   */
  private java.math.BigDecimal totalSuttleEndswith;
  /**
   * 总净重 比较(isnull)
   */
  private Boolean totalSuttleIsnull;
  /**
   * 总净重 比较(isnotnull)
   */
  private Boolean totalSuttleIsnotnull;

  /**
   * 总毛重
   */
  private java.math.BigDecimal totalGross;

  /**
   * 最小总毛重
   */
  private java.math.BigDecimal totalGrossMin;

  /**
   * 最大总毛重
   */
  private java.math.BigDecimal totalGrossMax;

  /**
   * 总毛重 比较(eq)
   */
  private java.math.BigDecimal totalGrossEq;
  /**
   * 总毛重 比较(neq)
   */
  private java.math.BigDecimal totalGrossNeq;
  /**
   * 总毛重 比较(gt)
   */
  private java.math.BigDecimal totalGrossGt;
  /**
   * 总毛重 比较(gte)
   */
  private java.math.BigDecimal totalGrossGte;
  /**
   * 总毛重 比较(lt)
   */
  private java.math.BigDecimal totalGrossLt;
  /**
   * 总毛重 比较(lte)
   */
  private java.math.BigDecimal totalGrossLte;
  /**
   * 总毛重 比较(contains)
   */
  private java.math.BigDecimal totalGrossContains;
  /**
   * 总毛重 比较(notcontains)
   */
  private java.math.BigDecimal totalGrossNotcontains;
  /**
   * 总毛重 比较(startswith)
   */
  private java.math.BigDecimal totalGrossStartswith;
  /**
   * 总毛重 比较(endswith)
   */
  private java.math.BigDecimal totalGrossEndswith;
  /**
   * 总毛重 比较(isnull)
   */
  private Boolean totalGrossIsnull;
  /**
   * 总毛重 比较(isnotnull)
   */
  private Boolean totalGrossIsnotnull;

  /**
   * 总体积
   */
  private java.math.BigDecimal totalVolume;

  /**
   * 最小总体积
   */
  private java.math.BigDecimal totalVolumeMin;

  /**
   * 最大总体积
   */
  private java.math.BigDecimal totalVolumeMax;

  /**
   * 总体积 比较(eq)
   */
  private java.math.BigDecimal totalVolumeEq;
  /**
   * 总体积 比较(neq)
   */
  private java.math.BigDecimal totalVolumeNeq;
  /**
   * 总体积 比较(gt)
   */
  private java.math.BigDecimal totalVolumeGt;
  /**
   * 总体积 比较(gte)
   */
  private java.math.BigDecimal totalVolumeGte;
  /**
   * 总体积 比较(lt)
   */
  private java.math.BigDecimal totalVolumeLt;
  /**
   * 总体积 比较(lte)
   */
  private java.math.BigDecimal totalVolumeLte;
  /**
   * 总体积 比较(contains)
   */
  private java.math.BigDecimal totalVolumeContains;
  /**
   * 总体积 比较(notcontains)
   */
  private java.math.BigDecimal totalVolumeNotcontains;
  /**
   * 总体积 比较(startswith)
   */
  private java.math.BigDecimal totalVolumeStartswith;
  /**
   * 总体积 比较(endswith)
   */
  private java.math.BigDecimal totalVolumeEndswith;
  /**
   * 总体积 比较(isnull)
   */
  private Boolean totalVolumeIsnull;
  /**
   * 总体积 比较(isnotnull)
   */
  private Boolean totalVolumeIsnotnull;

  /**
   * 所属发货单
   */
  private Long parentFBAInvoice;

  /**
   * 所属发货单 比较(eq)
   */
  private Long parentFBAInvoiceEq;
  /**
   * 所属发货单 比较(neq)
   */
  private Long parentFBAInvoiceNeq;
  /**
   * 所属发货单 比较(gt)
   */
  private Long parentFBAInvoiceGt;
  /**
   * 所属发货单 比较(gte)
   */
  private Long parentFBAInvoiceGte;
  /**
   * 所属发货单 比较(lt)
   */
  private Long parentFBAInvoiceLt;
  /**
   * 所属发货单 比较(lte)
   */
  private Long parentFBAInvoiceLte;
  /**
   * 所属发货单 比较(contains)
   */
  private Long parentFBAInvoiceContains;
  /**
   * 所属发货单 比较(notcontains)
   */
  private Long parentFBAInvoiceNotcontains;
  /**
   * 所属发货单 比较(startswith)
   */
  private Long parentFBAInvoiceStartswith;
  /**
   * 所属发货单 比较(endswith)
   */
  private Long parentFBAInvoiceEndswith;
  /**
   * 所属发货单 比较(isnull)
   */
  private Boolean parentFBAInvoiceIsnull;
  /**
   * 所属发货单 比较(isnotnull)
   */
  private Boolean parentFBAInvoiceIsnotnull;
  /**
   * 所属发货单的物流商 比较(eq)
   */
  private String parentFBAInvoiceLogisticsProviderEq;
  /**
   * 所属发货单的物流商 比较(neq)
   */
  private String parentFBAInvoiceLogisticsProviderNeq;
  /**
   * 所属发货单的物流商 比较(gt)
   */
  private String parentFBAInvoiceLogisticsProviderGt;
  /**
   * 所属发货单的物流商 比较(gte)
   */
  private String parentFBAInvoiceLogisticsProviderGte;
  /**
   * 所属发货单的物流商 比较(lt)
   */
  private String parentFBAInvoiceLogisticsProviderLt;
  /**
   * 所属发货单的物流商 比较(lte)
   */
  private String parentFBAInvoiceLogisticsProviderLte;
  /**
   * 所属发货单的物流商 比较(contains)
   */
  private String parentFBAInvoiceLogisticsProviderContains;
  /**
   * 所属发货单的物流商 比较(notcontains)
   */
  private String parentFBAInvoiceLogisticsProviderNotcontains;
  /**
   * 所属发货单的物流商 比较(startswith)
   */
  private String parentFBAInvoiceLogisticsProviderStartswith;
  /**
   * 所属发货单的物流商 比较(endswith)
   */
  private String parentFBAInvoiceLogisticsProviderEndswith;
  /**
   * 所属发货单的物流商 比较(isnull)
   */
  private Boolean parentFBAInvoiceLogisticsProviderIsnull;
  /**
   * 所属发货单的物流商 比较(isnotnull)
   */
  private Boolean parentFBAInvoiceLogisticsProviderIsnotnull;

  /**
   * 所属发货单(范围搜索)
   */
  private List<Long> parentFBAInvoiceInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 税费
   */
  private java.math.BigDecimal taxAmount;

  /**
   * 最小税费
   */
  private java.math.BigDecimal taxAmountMin;

  /**
   * 最大税费
   */
  private java.math.BigDecimal taxAmountMax;

  /**
   * 税费 比较(eq)
   */
  private java.math.BigDecimal taxAmountEq;
  /**
   * 税费 比较(neq)
   */
  private java.math.BigDecimal taxAmountNeq;
  /**
   * 税费 比较(gt)
   */
  private java.math.BigDecimal taxAmountGt;
  /**
   * 税费 比较(gte)
   */
  private java.math.BigDecimal taxAmountGte;
  /**
   * 税费 比较(lt)
   */
  private java.math.BigDecimal taxAmountLt;
  /**
   * 税费 比较(lte)
   */
  private java.math.BigDecimal taxAmountLte;
  /**
   * 税费 比较(contains)
   */
  private java.math.BigDecimal taxAmountContains;
  /**
   * 税费 比较(notcontains)
   */
  private java.math.BigDecimal taxAmountNotcontains;
  /**
   * 税费 比较(startswith)
   */
  private java.math.BigDecimal taxAmountStartswith;
  /**
   * 税费 比较(endswith)
   */
  private java.math.BigDecimal taxAmountEndswith;
  /**
   * 税费 比较(isnull)
   */
  private Boolean taxAmountIsnull;
  /**
   * 税费 比较(isnotnull)
   */
  private Boolean taxAmountIsnotnull;

  /**
   * 仓库
   */
  private Long warehouse;

  /**
   * 仓库 比较(eq)
   */
  private Long warehouseEq;
  /**
   * 仓库 比较(neq)
   */
  private Long warehouseNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long warehouseGt;
  /**
   * 仓库 比较(gte)
   */
  private Long warehouseGte;
  /**
   * 仓库 比较(lt)
   */
  private Long warehouseLt;
  /**
   * 仓库 比较(lte)
   */
  private Long warehouseLte;
  /**
   * 仓库 比较(contains)
   */
  private Long warehouseContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long warehouseNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long warehouseStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long warehouseEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean warehouseIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean warehouseIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String warehouseNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String warehouseNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String warehouseNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String warehouseNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String warehouseNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String warehouseNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String warehouseNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String warehouseNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String warehouseNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String warehouseNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean warehouseNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean warehouseNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> warehouseInList;

  /**
   * 发货仓库FNSKU(模糊搜索)
   */
  private String shipmentShopFnsku;

  /**
   * 发货仓库FNSKU 比较(eq)
   */
  private String shipmentShopFnskuEq;
  /**
   * 发货仓库FNSKU 比较(neq)
   */
  private String shipmentShopFnskuNeq;
  /**
   * 发货仓库FNSKU 比较(gt)
   */
  private String shipmentShopFnskuGt;
  /**
   * 发货仓库FNSKU 比较(gte)
   */
  private String shipmentShopFnskuGte;
  /**
   * 发货仓库FNSKU 比较(lt)
   */
  private String shipmentShopFnskuLt;
  /**
   * 发货仓库FNSKU 比较(lte)
   */
  private String shipmentShopFnskuLte;
  /**
   * 发货仓库FNSKU 比较(contains)
   */
  private String shipmentShopFnskuContains;
  /**
   * 发货仓库FNSKU 比较(notcontains)
   */
  private String shipmentShopFnskuNotcontains;
  /**
   * 发货仓库FNSKU 比较(startswith)
   */
  private String shipmentShopFnskuStartswith;
  /**
   * 发货仓库FNSKU 比较(endswith)
   */
  private String shipmentShopFnskuEndswith;
  /**
   * 发货仓库FNSKU 比较(isnull)
   */
  private Boolean shipmentShopFnskuIsnull;
  /**
   * 发货仓库FNSKU 比较(isnotnull)
   */
  private Boolean shipmentShopFnskuIsnotnull;

  /**
   * 发货仓库FNSKU(精确搜索)
   */
  private List<String> shipmentShopFnskuInList;

  /**
   * 发货仓库店铺
   */
  private Long shipmentShop;

  /**
   * 发货仓库店铺 比较(eq)
   */
  private Long shipmentShopEq;
  /**
   * 发货仓库店铺 比较(neq)
   */
  private Long shipmentShopNeq;
  /**
   * 发货仓库店铺 比较(gt)
   */
  private Long shipmentShopGt;
  /**
   * 发货仓库店铺 比较(gte)
   */
  private Long shipmentShopGte;
  /**
   * 发货仓库店铺 比较(lt)
   */
  private Long shipmentShopLt;
  /**
   * 发货仓库店铺 比较(lte)
   */
  private Long shipmentShopLte;
  /**
   * 发货仓库店铺 比较(contains)
   */
  private Long shipmentShopContains;
  /**
   * 发货仓库店铺 比较(notcontains)
   */
  private Long shipmentShopNotcontains;
  /**
   * 发货仓库店铺 比较(startswith)
   */
  private Long shipmentShopStartswith;
  /**
   * 发货仓库店铺 比较(endswith)
   */
  private Long shipmentShopEndswith;
  /**
   * 发货仓库店铺 比较(isnull)
   */
  private Boolean shipmentShopIsnull;
  /**
   * 发货仓库店铺 比较(isnotnull)
   */
  private Boolean shipmentShopIsnotnull;
  /**
   * 发货仓库店铺的名称 比较(eq)
   */
  private String shipmentShopShopNameEq;
  /**
   * 发货仓库店铺的名称 比较(neq)
   */
  private String shipmentShopShopNameNeq;
  /**
   * 发货仓库店铺的名称 比较(gt)
   */
  private String shipmentShopShopNameGt;
  /**
   * 发货仓库店铺的名称 比较(gte)
   */
  private String shipmentShopShopNameGte;
  /**
   * 发货仓库店铺的名称 比较(lt)
   */
  private String shipmentShopShopNameLt;
  /**
   * 发货仓库店铺的名称 比较(lte)
   */
  private String shipmentShopShopNameLte;
  /**
   * 发货仓库店铺的名称 比较(contains)
   */
  private String shipmentShopShopNameContains;
  /**
   * 发货仓库店铺的名称 比较(notcontains)
   */
  private String shipmentShopShopNameNotcontains;
  /**
   * 发货仓库店铺的名称 比较(startswith)
   */
  private String shipmentShopShopNameStartswith;
  /**
   * 发货仓库店铺的名称 比较(endswith)
   */
  private String shipmentShopShopNameEndswith;
  /**
   * 发货仓库店铺的名称 比较(isnull)
   */
  private Boolean shipmentShopShopNameIsnull;
  /**
   * 发货仓库店铺的名称 比较(isnotnull)
   */
  private Boolean shipmentShopShopNameIsnotnull;

  /**
   * 发货仓库店铺(范围搜索)
   */
  private List<Long> shipmentShopInList;

  /**
   * 仓位
   */
  private Long warehouseBin;

  /**
   * 仓位 比较(eq)
   */
  private Long warehouseBinEq;
  /**
   * 仓位 比较(neq)
   */
  private Long warehouseBinNeq;
  /**
   * 仓位 比较(gt)
   */
  private Long warehouseBinGt;
  /**
   * 仓位 比较(gte)
   */
  private Long warehouseBinGte;
  /**
   * 仓位 比较(lt)
   */
  private Long warehouseBinLt;
  /**
   * 仓位 比较(lte)
   */
  private Long warehouseBinLte;
  /**
   * 仓位 比较(contains)
   */
  private Long warehouseBinContains;
  /**
   * 仓位 比较(notcontains)
   */
  private Long warehouseBinNotcontains;
  /**
   * 仓位 比较(startswith)
   */
  private Long warehouseBinStartswith;
  /**
   * 仓位 比较(endswith)
   */
  private Long warehouseBinEndswith;
  /**
   * 仓位 比较(isnull)
   */
  private Boolean warehouseBinIsnull;
  /**
   * 仓位 比较(isnotnull)
   */
  private Boolean warehouseBinIsnotnull;
  /**
   * 仓位的仓位 比较(eq)
   */
  private String warehouseBinStorageBinEq;
  /**
   * 仓位的仓位 比较(neq)
   */
  private String warehouseBinStorageBinNeq;
  /**
   * 仓位的仓位 比较(gt)
   */
  private String warehouseBinStorageBinGt;
  /**
   * 仓位的仓位 比较(gte)
   */
  private String warehouseBinStorageBinGte;
  /**
   * 仓位的仓位 比较(lt)
   */
  private String warehouseBinStorageBinLt;
  /**
   * 仓位的仓位 比较(lte)
   */
  private String warehouseBinStorageBinLte;
  /**
   * 仓位的仓位 比较(contains)
   */
  private String warehouseBinStorageBinContains;
  /**
   * 仓位的仓位 比较(notcontains)
   */
  private String warehouseBinStorageBinNotcontains;
  /**
   * 仓位的仓位 比较(startswith)
   */
  private String warehouseBinStorageBinStartswith;
  /**
   * 仓位的仓位 比较(endswith)
   */
  private String warehouseBinStorageBinEndswith;
  /**
   * 仓位的仓位 比较(isnull)
   */
  private Boolean warehouseBinStorageBinIsnull;
  /**
   * 仓位的仓位 比较(isnotnull)
   */
  private Boolean warehouseBinStorageBinIsnotnull;

  /**
   * 仓位(范围搜索)
   */
  private List<Long> warehouseBinInList;

  /**
   * 仓位数量
   */
  private Integer warehouseBinNum;

  /**
   * 最小仓位数量
   */
  private Integer warehouseBinNumMin;

  /**
   * 最大仓位数量
   */
  private Integer warehouseBinNumMax;

  /**
   * 仓位数量 比较(eq)
   */
  private Integer warehouseBinNumEq;
  /**
   * 仓位数量 比较(neq)
   */
  private Integer warehouseBinNumNeq;
  /**
   * 仓位数量 比较(gt)
   */
  private Integer warehouseBinNumGt;
  /**
   * 仓位数量 比较(gte)
   */
  private Integer warehouseBinNumGte;
  /**
   * 仓位数量 比较(lt)
   */
  private Integer warehouseBinNumLt;
  /**
   * 仓位数量 比较(lte)
   */
  private Integer warehouseBinNumLte;
  /**
   * 仓位数量 比较(contains)
   */
  private Integer warehouseBinNumContains;
  /**
   * 仓位数量 比较(notcontains)
   */
  private Integer warehouseBinNumNotcontains;
  /**
   * 仓位数量 比较(startswith)
   */
  private Integer warehouseBinNumStartswith;
  /**
   * 仓位数量 比较(endswith)
   */
  private Integer warehouseBinNumEndswith;
  /**
   * 仓位数量 比较(isnull)
   */
  private Boolean warehouseBinNumIsnull;
  /**
   * 仓位数量 比较(isnotnull)
   */
  private Boolean warehouseBinNumIsnotnull;

  /**
   * 箱数
   */
  private Integer boxNum;

  /**
   * 最小箱数
   */
  private Integer boxNumMin;

  /**
   * 最大箱数
   */
  private Integer boxNumMax;

  /**
   * 箱数 比较(eq)
   */
  private Integer boxNumEq;
  /**
   * 箱数 比较(neq)
   */
  private Integer boxNumNeq;
  /**
   * 箱数 比较(gt)
   */
  private Integer boxNumGt;
  /**
   * 箱数 比较(gte)
   */
  private Integer boxNumGte;
  /**
   * 箱数 比较(lt)
   */
  private Integer boxNumLt;
  /**
   * 箱数 比较(lte)
   */
  private Integer boxNumLte;
  /**
   * 箱数 比较(contains)
   */
  private Integer boxNumContains;
  /**
   * 箱数 比较(notcontains)
   */
  private Integer boxNumNotcontains;
  /**
   * 箱数 比较(startswith)
   */
  private Integer boxNumStartswith;
  /**
   * 箱数 比较(endswith)
   */
  private Integer boxNumEndswith;
  /**
   * 箱数 比较(isnull)
   */
  private Boolean boxNumIsnull;
  /**
   * 箱数 比较(isnotnull)
   */
  private Boolean boxNumIsnotnull;

  /**
   * 箱规名称(模糊搜索)
   */
  private String boxList;

  /**
   * 箱规名称 比较(eq)
   */
  private String boxListEq;
  /**
   * 箱规名称 比较(neq)
   */
  private String boxListNeq;
  /**
   * 箱规名称 比较(gt)
   */
  private String boxListGt;
  /**
   * 箱规名称 比较(gte)
   */
  private String boxListGte;
  /**
   * 箱规名称 比较(lt)
   */
  private String boxListLt;
  /**
   * 箱规名称 比较(lte)
   */
  private String boxListLte;
  /**
   * 箱规名称 比较(contains)
   */
  private String boxListContains;
  /**
   * 箱规名称 比较(notcontains)
   */
  private String boxListNotcontains;
  /**
   * 箱规名称 比较(startswith)
   */
  private String boxListStartswith;
  /**
   * 箱规名称 比较(endswith)
   */
  private String boxListEndswith;
  /**
   * 箱规名称 比较(isnull)
   */
  private Boolean boxListIsnull;
  /**
   * 箱规名称 比较(isnotnull)
   */
  private Boolean boxListIsnotnull;

  /**
   * 箱规名称(精确搜索)
   */
  private List<String> boxListInList;

  /**
   * 箱子毛重（kg）
   */
  private java.math.BigDecimal boxGross;

  /**
   * 最小箱子毛重（kg）
   */
  private java.math.BigDecimal boxGrossMin;

  /**
   * 最大箱子毛重（kg）
   */
  private java.math.BigDecimal boxGrossMax;

  /**
   * 箱子毛重（kg） 比较(eq)
   */
  private java.math.BigDecimal boxGrossEq;
  /**
   * 箱子毛重（kg） 比较(neq)
   */
  private java.math.BigDecimal boxGrossNeq;
  /**
   * 箱子毛重（kg） 比较(gt)
   */
  private java.math.BigDecimal boxGrossGt;
  /**
   * 箱子毛重（kg） 比较(gte)
   */
  private java.math.BigDecimal boxGrossGte;
  /**
   * 箱子毛重（kg） 比较(lt)
   */
  private java.math.BigDecimal boxGrossLt;
  /**
   * 箱子毛重（kg） 比较(lte)
   */
  private java.math.BigDecimal boxGrossLte;
  /**
   * 箱子毛重（kg） 比较(contains)
   */
  private java.math.BigDecimal boxGrossContains;
  /**
   * 箱子毛重（kg） 比较(notcontains)
   */
  private java.math.BigDecimal boxGrossNotcontains;
  /**
   * 箱子毛重（kg） 比较(startswith)
   */
  private java.math.BigDecimal boxGrossStartswith;
  /**
   * 箱子毛重（kg） 比较(endswith)
   */
  private java.math.BigDecimal boxGrossEndswith;
  /**
   * 箱子毛重（kg） 比较(isnull)
   */
  private Boolean boxGrossIsnull;
  /**
   * 箱子毛重（kg） 比较(isnotnull)
   */
  private Boolean boxGrossIsnotnull;

  /**
   * 箱子长(cm)
   */
  private java.math.BigDecimal boxLength;

  /**
   * 最小箱子长(cm)
   */
  private java.math.BigDecimal boxLengthMin;

  /**
   * 最大箱子长(cm)
   */
  private java.math.BigDecimal boxLengthMax;

  /**
   * 箱子长(cm) 比较(eq)
   */
  private java.math.BigDecimal boxLengthEq;
  /**
   * 箱子长(cm) 比较(neq)
   */
  private java.math.BigDecimal boxLengthNeq;
  /**
   * 箱子长(cm) 比较(gt)
   */
  private java.math.BigDecimal boxLengthGt;
  /**
   * 箱子长(cm) 比较(gte)
   */
  private java.math.BigDecimal boxLengthGte;
  /**
   * 箱子长(cm) 比较(lt)
   */
  private java.math.BigDecimal boxLengthLt;
  /**
   * 箱子长(cm) 比较(lte)
   */
  private java.math.BigDecimal boxLengthLte;
  /**
   * 箱子长(cm) 比较(contains)
   */
  private java.math.BigDecimal boxLengthContains;
  /**
   * 箱子长(cm) 比较(notcontains)
   */
  private java.math.BigDecimal boxLengthNotcontains;
  /**
   * 箱子长(cm) 比较(startswith)
   */
  private java.math.BigDecimal boxLengthStartswith;
  /**
   * 箱子长(cm) 比较(endswith)
   */
  private java.math.BigDecimal boxLengthEndswith;
  /**
   * 箱子长(cm) 比较(isnull)
   */
  private Boolean boxLengthIsnull;
  /**
   * 箱子长(cm) 比较(isnotnull)
   */
  private Boolean boxLengthIsnotnull;

  /**
   * 箱子宽
   */
  private java.math.BigDecimal boxWidth;

  /**
   * 最小箱子宽
   */
  private java.math.BigDecimal boxWidthMin;

  /**
   * 最大箱子宽
   */
  private java.math.BigDecimal boxWidthMax;

  /**
   * 箱子宽 比较(eq)
   */
  private java.math.BigDecimal boxWidthEq;
  /**
   * 箱子宽 比较(neq)
   */
  private java.math.BigDecimal boxWidthNeq;
  /**
   * 箱子宽 比较(gt)
   */
  private java.math.BigDecimal boxWidthGt;
  /**
   * 箱子宽 比较(gte)
   */
  private java.math.BigDecimal boxWidthGte;
  /**
   * 箱子宽 比较(lt)
   */
  private java.math.BigDecimal boxWidthLt;
  /**
   * 箱子宽 比较(lte)
   */
  private java.math.BigDecimal boxWidthLte;
  /**
   * 箱子宽 比较(contains)
   */
  private java.math.BigDecimal boxWidthContains;
  /**
   * 箱子宽 比较(notcontains)
   */
  private java.math.BigDecimal boxWidthNotcontains;
  /**
   * 箱子宽 比较(startswith)
   */
  private java.math.BigDecimal boxWidthStartswith;
  /**
   * 箱子宽 比较(endswith)
   */
  private java.math.BigDecimal boxWidthEndswith;
  /**
   * 箱子宽 比较(isnull)
   */
  private Boolean boxWidthIsnull;
  /**
   * 箱子宽 比较(isnotnull)
   */
  private Boolean boxWidthIsnotnull;

  /**
   * 箱子高
   */
  private java.math.BigDecimal boxHeight;

  /**
   * 最小箱子高
   */
  private java.math.BigDecimal boxHeightMin;

  /**
   * 最大箱子高
   */
  private java.math.BigDecimal boxHeightMax;

  /**
   * 箱子高 比较(eq)
   */
  private java.math.BigDecimal boxHeightEq;
  /**
   * 箱子高 比较(neq)
   */
  private java.math.BigDecimal boxHeightNeq;
  /**
   * 箱子高 比较(gt)
   */
  private java.math.BigDecimal boxHeightGt;
  /**
   * 箱子高 比较(gte)
   */
  private java.math.BigDecimal boxHeightGte;
  /**
   * 箱子高 比较(lt)
   */
  private java.math.BigDecimal boxHeightLt;
  /**
   * 箱子高 比较(lte)
   */
  private java.math.BigDecimal boxHeightLte;
  /**
   * 箱子高 比较(contains)
   */
  private java.math.BigDecimal boxHeightContains;
  /**
   * 箱子高 比较(notcontains)
   */
  private java.math.BigDecimal boxHeightNotcontains;
  /**
   * 箱子高 比较(startswith)
   */
  private java.math.BigDecimal boxHeightStartswith;
  /**
   * 箱子高 比较(endswith)
   */
  private java.math.BigDecimal boxHeightEndswith;
  /**
   * 箱子高 比较(isnull)
   */
  private Boolean boxHeightIsnull;
  /**
   * 箱子高 比较(isnotnull)
   */
  private Boolean boxHeightIsnotnull;

  /**
   * 单箱数量
   */
  private Integer quantityInCase;

  /**
   * 最小单箱数量
   */
  private Integer quantityInCaseMin;

  /**
   * 最大单箱数量
   */
  private Integer quantityInCaseMax;

  /**
   * 单箱数量 比较(eq)
   */
  private Integer quantityInCaseEq;
  /**
   * 单箱数量 比较(neq)
   */
  private Integer quantityInCaseNeq;
  /**
   * 单箱数量 比较(gt)
   */
  private Integer quantityInCaseGt;
  /**
   * 单箱数量 比较(gte)
   */
  private Integer quantityInCaseGte;
  /**
   * 单箱数量 比较(lt)
   */
  private Integer quantityInCaseLt;
  /**
   * 单箱数量 比较(lte)
   */
  private Integer quantityInCaseLte;
  /**
   * 单箱数量 比较(contains)
   */
  private Integer quantityInCaseContains;
  /**
   * 单箱数量 比较(notcontains)
   */
  private Integer quantityInCaseNotcontains;
  /**
   * 单箱数量 比较(startswith)
   */
  private Integer quantityInCaseStartswith;
  /**
   * 单箱数量 比较(endswith)
   */
  private Integer quantityInCaseEndswith;
  /**
   * 单箱数量 比较(isnull)
   */
  private Boolean quantityInCaseIsnull;
  /**
   * 单箱数量 比较(isnotnull)
   */
  private Boolean quantityInCaseIsnotnull;

  /**
   * CBM
   */
  private java.math.BigDecimal cbm;

  /**
   * 最小CBM
   */
  private java.math.BigDecimal cbmMin;

  /**
   * 最大CBM
   */
  private java.math.BigDecimal cbmMax;

  /**
   * CBM 比较(eq)
   */
  private java.math.BigDecimal cbmEq;
  /**
   * CBM 比较(neq)
   */
  private java.math.BigDecimal cbmNeq;
  /**
   * CBM 比较(gt)
   */
  private java.math.BigDecimal cbmGt;
  /**
   * CBM 比较(gte)
   */
  private java.math.BigDecimal cbmGte;
  /**
   * CBM 比较(lt)
   */
  private java.math.BigDecimal cbmLt;
  /**
   * CBM 比较(lte)
   */
  private java.math.BigDecimal cbmLte;
  /**
   * CBM 比较(contains)
   */
  private java.math.BigDecimal cbmContains;
  /**
   * CBM 比较(notcontains)
   */
  private java.math.BigDecimal cbmNotcontains;
  /**
   * CBM 比较(startswith)
   */
  private java.math.BigDecimal cbmStartswith;
  /**
   * CBM 比较(endswith)
   */
  private java.math.BigDecimal cbmEndswith;
  /**
   * CBM 比较(isnull)
   */
  private Boolean cbmIsnull;
  /**
   * CBM 比较(isnotnull)
   */
  private Boolean cbmIsnotnull;

  /**
   * 总重量（kg）
   */
  private java.math.BigDecimal tatolWeight;

  /**
   * 最小总重量（kg）
   */
  private java.math.BigDecimal tatolWeightMin;

  /**
   * 最大总重量（kg）
   */
  private java.math.BigDecimal tatolWeightMax;

  /**
   * 总重量（kg） 比较(eq)
   */
  private java.math.BigDecimal tatolWeightEq;
  /**
   * 总重量（kg） 比较(neq)
   */
  private java.math.BigDecimal tatolWeightNeq;
  /**
   * 总重量（kg） 比较(gt)
   */
  private java.math.BigDecimal tatolWeightGt;
  /**
   * 总重量（kg） 比较(gte)
   */
  private java.math.BigDecimal tatolWeightGte;
  /**
   * 总重量（kg） 比较(lt)
   */
  private java.math.BigDecimal tatolWeightLt;
  /**
   * 总重量（kg） 比较(lte)
   */
  private java.math.BigDecimal tatolWeightLte;
  /**
   * 总重量（kg） 比较(contains)
   */
  private java.math.BigDecimal tatolWeightContains;
  /**
   * 总重量（kg） 比较(notcontains)
   */
  private java.math.BigDecimal tatolWeightNotcontains;
  /**
   * 总重量（kg） 比较(startswith)
   */
  private java.math.BigDecimal tatolWeightStartswith;
  /**
   * 总重量（kg） 比较(endswith)
   */
  private java.math.BigDecimal tatolWeightEndswith;
  /**
   * 总重量（kg） 比较(isnull)
   */
  private Boolean tatolWeightIsnull;
  /**
   * 总重量（kg） 比较(isnotnull)
   */
  private Boolean tatolWeightIsnotnull;

  /**
   * 总体积重
   */
  private java.math.BigDecimal tatolVolumeWeight;

  /**
   * 最小总体积重
   */
  private java.math.BigDecimal tatolVolumeWeightMin;

  /**
   * 最大总体积重
   */
  private java.math.BigDecimal tatolVolumeWeightMax;

  /**
   * 总体积重 比较(eq)
   */
  private java.math.BigDecimal tatolVolumeWeightEq;
  /**
   * 总体积重 比较(neq)
   */
  private java.math.BigDecimal tatolVolumeWeightNeq;
  /**
   * 总体积重 比较(gt)
   */
  private java.math.BigDecimal tatolVolumeWeightGt;
  /**
   * 总体积重 比较(gte)
   */
  private java.math.BigDecimal tatolVolumeWeightGte;
  /**
   * 总体积重 比较(lt)
   */
  private java.math.BigDecimal tatolVolumeWeightLt;
  /**
   * 总体积重 比较(lte)
   */
  private java.math.BigDecimal tatolVolumeWeightLte;
  /**
   * 总体积重 比较(contains)
   */
  private java.math.BigDecimal tatolVolumeWeightContains;
  /**
   * 总体积重 比较(notcontains)
   */
  private java.math.BigDecimal tatolVolumeWeightNotcontains;
  /**
   * 总体积重 比较(startswith)
   */
  private java.math.BigDecimal tatolVolumeWeightStartswith;
  /**
   * 总体积重 比较(endswith)
   */
  private java.math.BigDecimal tatolVolumeWeightEndswith;
  /**
   * 总体积重 比较(isnull)
   */
  private Boolean tatolVolumeWeightIsnull;
  /**
   * 总体积重 比较(isnotnull)
   */
  private Boolean tatolVolumeWeightIsnotnull;

  /**
   * 单品净重
   */
  private java.math.BigDecimal oneSuttle;

  /**
   * 最小单品净重
   */
  private java.math.BigDecimal oneSuttleMin;

  /**
   * 最大单品净重
   */
  private java.math.BigDecimal oneSuttleMax;

  /**
   * 单品净重 比较(eq)
   */
  private java.math.BigDecimal oneSuttleEq;
  /**
   * 单品净重 比较(neq)
   */
  private java.math.BigDecimal oneSuttleNeq;
  /**
   * 单品净重 比较(gt)
   */
  private java.math.BigDecimal oneSuttleGt;
  /**
   * 单品净重 比较(gte)
   */
  private java.math.BigDecimal oneSuttleGte;
  /**
   * 单品净重 比较(lt)
   */
  private java.math.BigDecimal oneSuttleLt;
  /**
   * 单品净重 比较(lte)
   */
  private java.math.BigDecimal oneSuttleLte;
  /**
   * 单品净重 比较(contains)
   */
  private java.math.BigDecimal oneSuttleContains;
  /**
   * 单品净重 比较(notcontains)
   */
  private java.math.BigDecimal oneSuttleNotcontains;
  /**
   * 单品净重 比较(startswith)
   */
  private java.math.BigDecimal oneSuttleStartswith;
  /**
   * 单品净重 比较(endswith)
   */
  private java.math.BigDecimal oneSuttleEndswith;
  /**
   * 单品净重 比较(isnull)
   */
  private Boolean oneSuttleIsnull;
  /**
   * 单品净重 比较(isnotnull)
   */
  private Boolean oneSuttleIsnotnull;

  /**
   * 单品毛重
   */
  private java.math.BigDecimal oneGross;

  /**
   * 最小单品毛重
   */
  private java.math.BigDecimal oneGrossMin;

  /**
   * 最大单品毛重
   */
  private java.math.BigDecimal oneGrossMax;

  /**
   * 单品毛重 比较(eq)
   */
  private java.math.BigDecimal oneGrossEq;
  /**
   * 单品毛重 比较(neq)
   */
  private java.math.BigDecimal oneGrossNeq;
  /**
   * 单品毛重 比较(gt)
   */
  private java.math.BigDecimal oneGrossGt;
  /**
   * 单品毛重 比较(gte)
   */
  private java.math.BigDecimal oneGrossGte;
  /**
   * 单品毛重 比较(lt)
   */
  private java.math.BigDecimal oneGrossLt;
  /**
   * 单品毛重 比较(lte)
   */
  private java.math.BigDecimal oneGrossLte;
  /**
   * 单品毛重 比较(contains)
   */
  private java.math.BigDecimal oneGrossContains;
  /**
   * 单品毛重 比较(notcontains)
   */
  private java.math.BigDecimal oneGrossNotcontains;
  /**
   * 单品毛重 比较(startswith)
   */
  private java.math.BigDecimal oneGrossStartswith;
  /**
   * 单品毛重 比较(endswith)
   */
  private java.math.BigDecimal oneGrossEndswith;
  /**
   * 单品毛重 比较(isnull)
   */
  private Boolean oneGrossIsnull;
  /**
   * 单品毛重 比较(isnotnull)
   */
  private Boolean oneGrossIsnotnull;

  /**
   * 包装规格（cm）长
   */
  private java.math.BigDecimal packageLength;

  /**
   * 最小包装规格（cm）长
   */
  private java.math.BigDecimal packageLengthMin;

  /**
   * 最大包装规格（cm）长
   */
  private java.math.BigDecimal packageLengthMax;

  /**
   * 包装规格（cm）长 比较(eq)
   */
  private java.math.BigDecimal packageLengthEq;
  /**
   * 包装规格（cm）长 比较(neq)
   */
  private java.math.BigDecimal packageLengthNeq;
  /**
   * 包装规格（cm）长 比较(gt)
   */
  private java.math.BigDecimal packageLengthGt;
  /**
   * 包装规格（cm）长 比较(gte)
   */
  private java.math.BigDecimal packageLengthGte;
  /**
   * 包装规格（cm）长 比较(lt)
   */
  private java.math.BigDecimal packageLengthLt;
  /**
   * 包装规格（cm）长 比较(lte)
   */
  private java.math.BigDecimal packageLengthLte;
  /**
   * 包装规格（cm）长 比较(contains)
   */
  private java.math.BigDecimal packageLengthContains;
  /**
   * 包装规格（cm）长 比较(notcontains)
   */
  private java.math.BigDecimal packageLengthNotcontains;
  /**
   * 包装规格（cm）长 比较(startswith)
   */
  private java.math.BigDecimal packageLengthStartswith;
  /**
   * 包装规格（cm）长 比较(endswith)
   */
  private java.math.BigDecimal packageLengthEndswith;
  /**
   * 包装规格（cm）长 比较(isnull)
   */
  private Boolean packageLengthIsnull;
  /**
   * 包装规格（cm）长 比较(isnotnull)
   */
  private Boolean packageLengthIsnotnull;

  /**
   * 包装规格（cm）宽
   */
  private java.math.BigDecimal packageWidth;

  /**
   * 最小包装规格（cm）宽
   */
  private java.math.BigDecimal packageWidthMin;

  /**
   * 最大包装规格（cm）宽
   */
  private java.math.BigDecimal packageWidthMax;

  /**
   * 包装规格（cm）宽 比较(eq)
   */
  private java.math.BigDecimal packageWidthEq;
  /**
   * 包装规格（cm）宽 比较(neq)
   */
  private java.math.BigDecimal packageWidthNeq;
  /**
   * 包装规格（cm）宽 比较(gt)
   */
  private java.math.BigDecimal packageWidthGt;
  /**
   * 包装规格（cm）宽 比较(gte)
   */
  private java.math.BigDecimal packageWidthGte;
  /**
   * 包装规格（cm）宽 比较(lt)
   */
  private java.math.BigDecimal packageWidthLt;
  /**
   * 包装规格（cm）宽 比较(lte)
   */
  private java.math.BigDecimal packageWidthLte;
  /**
   * 包装规格（cm）宽 比较(contains)
   */
  private java.math.BigDecimal packageWidthContains;
  /**
   * 包装规格（cm）宽 比较(notcontains)
   */
  private java.math.BigDecimal packageWidthNotcontains;
  /**
   * 包装规格（cm）宽 比较(startswith)
   */
  private java.math.BigDecimal packageWidthStartswith;
  /**
   * 包装规格（cm）宽 比较(endswith)
   */
  private java.math.BigDecimal packageWidthEndswith;
  /**
   * 包装规格（cm）宽 比较(isnull)
   */
  private Boolean packageWidthIsnull;
  /**
   * 包装规格（cm）宽 比较(isnotnull)
   */
  private Boolean packageWidthIsnotnull;

  /**
   * 包装规格（cm）高
   */
  private java.math.BigDecimal packageHeight;

  /**
   * 最小包装规格（cm）高
   */
  private java.math.BigDecimal packageHeightMin;

  /**
   * 最大包装规格（cm）高
   */
  private java.math.BigDecimal packageHeightMax;

  /**
   * 包装规格（cm）高 比较(eq)
   */
  private java.math.BigDecimal packageHeightEq;
  /**
   * 包装规格（cm）高 比较(neq)
   */
  private java.math.BigDecimal packageHeightNeq;
  /**
   * 包装规格（cm）高 比较(gt)
   */
  private java.math.BigDecimal packageHeightGt;
  /**
   * 包装规格（cm）高 比较(gte)
   */
  private java.math.BigDecimal packageHeightGte;
  /**
   * 包装规格（cm）高 比较(lt)
   */
  private java.math.BigDecimal packageHeightLt;
  /**
   * 包装规格（cm）高 比较(lte)
   */
  private java.math.BigDecimal packageHeightLte;
  /**
   * 包装规格（cm）高 比较(contains)
   */
  private java.math.BigDecimal packageHeightContains;
  /**
   * 包装规格（cm）高 比较(notcontains)
   */
  private java.math.BigDecimal packageHeightNotcontains;
  /**
   * 包装规格（cm）高 比较(startswith)
   */
  private java.math.BigDecimal packageHeightStartswith;
  /**
   * 包装规格（cm）高 比较(endswith)
   */
  private java.math.BigDecimal packageHeightEndswith;
  /**
   * 包装规格（cm）高 比较(isnull)
   */
  private Boolean packageHeightIsnull;
  /**
   * 包装规格（cm）高 比较(isnotnull)
   */
  private Boolean packageHeightIsnotnull;

  /**
   * 仓位编码(模糊搜索)
   */
  private String whbCode;

  /**
   * 仓位编码 比较(eq)
   */
  private String whbCodeEq;
  /**
   * 仓位编码 比较(neq)
   */
  private String whbCodeNeq;
  /**
   * 仓位编码 比较(gt)
   */
  private String whbCodeGt;
  /**
   * 仓位编码 比较(gte)
   */
  private String whbCodeGte;
  /**
   * 仓位编码 比较(lt)
   */
  private String whbCodeLt;
  /**
   * 仓位编码 比较(lte)
   */
  private String whbCodeLte;
  /**
   * 仓位编码 比较(contains)
   */
  private String whbCodeContains;
  /**
   * 仓位编码 比较(notcontains)
   */
  private String whbCodeNotcontains;
  /**
   * 仓位编码 比较(startswith)
   */
  private String whbCodeStartswith;
  /**
   * 仓位编码 比较(endswith)
   */
  private String whbCodeEndswith;
  /**
   * 仓位编码 比较(isnull)
   */
  private Boolean whbCodeIsnull;
  /**
   * 仓位编码 比较(isnotnull)
   */
  private Boolean whbCodeIsnotnull;

  /**
   * 仓位编码(精确搜索)
   */
  private List<String> whbCodeInList;

  /**
   * 可用仓位
   */
  private Long outBingId;

  /**
   * 可用仓位 比较(eq)
   */
  private Long outBingIdEq;
  /**
   * 可用仓位 比较(neq)
   */
  private Long outBingIdNeq;
  /**
   * 可用仓位 比较(gt)
   */
  private Long outBingIdGt;
  /**
   * 可用仓位 比较(gte)
   */
  private Long outBingIdGte;
  /**
   * 可用仓位 比较(lt)
   */
  private Long outBingIdLt;
  /**
   * 可用仓位 比较(lte)
   */
  private Long outBingIdLte;
  /**
   * 可用仓位 比较(contains)
   */
  private Long outBingIdContains;
  /**
   * 可用仓位 比较(notcontains)
   */
  private Long outBingIdNotcontains;
  /**
   * 可用仓位 比较(startswith)
   */
  private Long outBingIdStartswith;
  /**
   * 可用仓位 比较(endswith)
   */
  private Long outBingIdEndswith;
  /**
   * 可用仓位 比较(isnull)
   */
  private Boolean outBingIdIsnull;
  /**
   * 可用仓位 比较(isnotnull)
   */
  private Boolean outBingIdIsnotnull;
  /**
   * 可用仓位的仓位 比较(eq)
   */
  private String outBingIdStorageBinEq;
  /**
   * 可用仓位的仓位 比较(neq)
   */
  private String outBingIdStorageBinNeq;
  /**
   * 可用仓位的仓位 比较(gt)
   */
  private String outBingIdStorageBinGt;
  /**
   * 可用仓位的仓位 比较(gte)
   */
  private String outBingIdStorageBinGte;
  /**
   * 可用仓位的仓位 比较(lt)
   */
  private String outBingIdStorageBinLt;
  /**
   * 可用仓位的仓位 比较(lte)
   */
  private String outBingIdStorageBinLte;
  /**
   * 可用仓位的仓位 比较(contains)
   */
  private String outBingIdStorageBinContains;
  /**
   * 可用仓位的仓位 比较(notcontains)
   */
  private String outBingIdStorageBinNotcontains;
  /**
   * 可用仓位的仓位 比较(startswith)
   */
  private String outBingIdStorageBinStartswith;
  /**
   * 可用仓位的仓位 比较(endswith)
   */
  private String outBingIdStorageBinEndswith;
  /**
   * 可用仓位的仓位 比较(isnull)
   */
  private Boolean outBingIdStorageBinIsnull;
  /**
   * 可用仓位的仓位 比较(isnotnull)
   */
  private Boolean outBingIdStorageBinIsnotnull;

  /**
   * 可用仓位(范围搜索)
   */
  private List<Long> outBingIdInList;

  /**
   * 可用暂存仓位
   */
  private Long inBingId;

  /**
   * 可用暂存仓位 比较(eq)
   */
  private Long inBingIdEq;
  /**
   * 可用暂存仓位 比较(neq)
   */
  private Long inBingIdNeq;
  /**
   * 可用暂存仓位 比较(gt)
   */
  private Long inBingIdGt;
  /**
   * 可用暂存仓位 比较(gte)
   */
  private Long inBingIdGte;
  /**
   * 可用暂存仓位 比较(lt)
   */
  private Long inBingIdLt;
  /**
   * 可用暂存仓位 比较(lte)
   */
  private Long inBingIdLte;
  /**
   * 可用暂存仓位 比较(contains)
   */
  private Long inBingIdContains;
  /**
   * 可用暂存仓位 比较(notcontains)
   */
  private Long inBingIdNotcontains;
  /**
   * 可用暂存仓位 比较(startswith)
   */
  private Long inBingIdStartswith;
  /**
   * 可用暂存仓位 比较(endswith)
   */
  private Long inBingIdEndswith;
  /**
   * 可用暂存仓位 比较(isnull)
   */
  private Boolean inBingIdIsnull;
  /**
   * 可用暂存仓位 比较(isnotnull)
   */
  private Boolean inBingIdIsnotnull;
  /**
   * 可用暂存仓位的仓位 比较(eq)
   */
  private String inBingIdStorageBinEq;
  /**
   * 可用暂存仓位的仓位 比较(neq)
   */
  private String inBingIdStorageBinNeq;
  /**
   * 可用暂存仓位的仓位 比较(gt)
   */
  private String inBingIdStorageBinGt;
  /**
   * 可用暂存仓位的仓位 比较(gte)
   */
  private String inBingIdStorageBinGte;
  /**
   * 可用暂存仓位的仓位 比较(lt)
   */
  private String inBingIdStorageBinLt;
  /**
   * 可用暂存仓位的仓位 比较(lte)
   */
  private String inBingIdStorageBinLte;
  /**
   * 可用暂存仓位的仓位 比较(contains)
   */
  private String inBingIdStorageBinContains;
  /**
   * 可用暂存仓位的仓位 比较(notcontains)
   */
  private String inBingIdStorageBinNotcontains;
  /**
   * 可用暂存仓位的仓位 比较(startswith)
   */
  private String inBingIdStorageBinStartswith;
  /**
   * 可用暂存仓位的仓位 比较(endswith)
   */
  private String inBingIdStorageBinEndswith;
  /**
   * 可用暂存仓位的仓位 比较(isnull)
   */
  private Boolean inBingIdStorageBinIsnull;
  /**
   * 可用暂存仓位的仓位 比较(isnotnull)
   */
  private Boolean inBingIdStorageBinIsnotnull;

  /**
   * 可用暂存仓位(范围搜索)
   */
  private List<Long> inBingIdInList;

  /**
   * 打印次数
   */
  private Integer printingsNum;

  /**
   * 最小打印次数
   */
  private Integer printingsNumMin;

  /**
   * 最大打印次数
   */
  private Integer printingsNumMax;

  /**
   * 打印次数 比较(eq)
   */
  private Integer printingsNumEq;
  /**
   * 打印次数 比较(neq)
   */
  private Integer printingsNumNeq;
  /**
   * 打印次数 比较(gt)
   */
  private Integer printingsNumGt;
  /**
   * 打印次数 比较(gte)
   */
  private Integer printingsNumGte;
  /**
   * 打印次数 比较(lt)
   */
  private Integer printingsNumLt;
  /**
   * 打印次数 比较(lte)
   */
  private Integer printingsNumLte;
  /**
   * 打印次数 比较(contains)
   */
  private Integer printingsNumContains;
  /**
   * 打印次数 比较(notcontains)
   */
  private Integer printingsNumNotcontains;
  /**
   * 打印次数 比较(startswith)
   */
  private Integer printingsNumStartswith;
  /**
   * 打印次数 比较(endswith)
   */
  private Integer printingsNumEndswith;
  /**
   * 打印次数 比较(isnull)
   */
  private Boolean printingsNumIsnull;
  /**
   * 打印次数 比较(isnotnull)
   */
  private Boolean printingsNumIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
